Section 2 – Une première expérience avec VS 2013

Retour à la page du cours

La deuxième section nous permettra de faire un premier contact avec Visual Studio 2013, notre IDE pour ce cours. Nous reprenons l'exemple du problème de Bouboule-O-Rama et nous verrons comment créer le programme à l'aide de Visual Studio.  On supposera que l'analyse et l'algorithme de la section 1.3 ont bel et bien été faits.

2.1 - Un projet

2.2 - La compilation

2.3 - Les commentaires

2.4 - Sauvegarder notre projet

2.1 - Un projet

Dans Visual Studio, une application est appelée un projet.  Lorsque l'on décide de faire un programme, on commence par créer un projet et à y placer des fichiers de code.  Votre première étape sera donc la création d'un nouveau projet.  Notez qu'on peut créer différents types de projets dans différents langages.  Dans le cadre de ce cours, nous nous limiterons aux applications console en C#.  Une application console est une application à l'interface très simpliste:  une seule fenêtre, pas de boutons, de menus ni de réelle utilisation de la souris; une seule police, une seule couleur de police, du texte qui est écrit de haut en bas sans possibilité de retour en arrière; un clavier pour que l'usager puisse saisir du texte. Ce genre d'application est évidemment un peu ennuyant et somme toute bien limité.  Toutefois, il faut bien commencer quelque part et le fait de ne pas se soucier de l'interface nous permettra de se concentrer davantage sur l'algorithme de chaque programme.  En session 2 on débutera les applications Windows, avec des fenêtres, des boutons, des boîtes de texte et des listes déroulantes. Pour créer un nouveau projet dans VS2013, il suffit d'aller dans les menus déroulants:

Une fois que c'est fait, vous devrez choisir le type et le langage du projet, en plus de déterminer où vous l'enregistrerez et comment il s'appellera:

 

Une fois tous ces choix réglés, vous vous retrouverez dans une fenêtre de ce genre:

 

Les trois grandes sections utiles de l'interface sont:

Si vous ne trouvez pas certaines sections de l'interface, c'est peut-être dû à votre configuration (ou peut-être que vous les avez simplement fermées par mégarde). Sachez que la plupart des fenêtres peuvent être cachées ou affichées à partir du menu Affichage ou Affichage->Autres fenêtres.

Dans la fenêtre de code se trouve déjà du code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
} 

En fait, ceci sert à déclarer le début et la fin du class, et le début et la fin du programme principal.  En effet, un projet C# est constitué de class dans lesquels on regroupe différentes fonctionnalités.  Dans le cadre du cours, tous vos projets ne contiendront qu'une seul class.

À l'intérieur de la class se trouve le "Main" ou programme principal.  Ce qu'on met ici est ce qui sera exécuté au démarrage du programme.  Lorsque vos programmes deviendront plus avancés, vous placerez des trucs hors du Main mais pour l'instant votre programme ira entre le "{" et le "}" qui délimitent le Main. Commençons alors notre projet de volume de boules de quilles...  On a déjà déterminé notre algorithme qui consistait en:  

PI <- 3.14
Lire  Rayon
Volume <- 4/3 * PI * Rayon ^ 3
Écrire  Volume

On devra traduire ces quatre lignes en code C#.  Ce n'est pas très compliqué, étant donné qu'on vient tout juste de voir les opérations de base. 

La première ligne est une assignation: on assigne la valeur 3.14 à la variable pi. En C# pour expliquer au compilateur que la valeur à assignée est un flot, on doit ajouter la lettre f ou F à la fin du chiffre. Pour l'affectation, on utilise le symbole "=". Il ne faut pas oublier non plus que dans du code C# le "." est utilisé comme séparateur de décimales (et pas la virgule!).  En C#, toutes les instructions doivent se terminer par un point-virgule.

 

pi = 3.14;

La deuxième ligne est une lecture au clavier, qui stockera la valeur lue dans la variable le_rayon_en_caracteres.  On utilisera le Console.ReadLine ainsi:

le_rayon_en_caracteres = Console.ReadLine();
rayon = float.Parse(le_rayon_en_caracteres);

En effet, Console.ReadLine va lire l'entrée de l'utilisateur, mais la valeur lue est de type string (chaine de caractères). On a besoin de la convertir vers un float. C'est pour cette raison qu'on emploie la fonction float.Parse qui va retourner le float qui se cache derrière la chaine de caractère. La troisième ligne est une autre assignation:  on assigne à la variable volume le résultat d'un calcul arithmétique impliquant le rayon et pi:

volume = (4 * pi * rayon * rayon * rayon)/3;

Grâce à la priorité des opérations, aucune parenthèse n'est nécessaire.  Finalement la dernière ligne est une écriture:  on écrit à l'écran le contenu fraîchement calculé de la variable volume.  On utilisera Console.WriteLine.  WriteLine a besoin d'une information pour faire son travail:  on doit lui dire quoi afficher.  On placera donc cette information entre les parenthèses.  Par contre, contrairement à ReadLine, elle ne retourne rien comme résultat (elle fait seulement son travail d'affichage):

Console.WriteLine(volume)

Voyons voir ce que ça donne placé au bon endroit dans notre code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {

            pi = 3.14159;
            le_rayon_en_caracteres = Console.ReadLine();
            rayon = float.Parse(le_rayon_en_caracteres);
            volume = rayon * pi * 4 / 3;
            Console.WriteLine(volume);
         }
    }
} 

Retour à la table des matières de la section

2.2 – La compilation

Pour pouvoir tester notre programme, on devra le compiler puis l'exécuter.  Pour faire la compilation, on choisira Générer -> Générer la solution (on peut également appuyer sur F6 ou F7 - vérifiez par vous-mêmes, ceci dépend de votre configuration).  Pour exécuter le programme ainsi compilé, on ira dans Déboguer -> Démarrer le débogage (on peut également appuyer sur F5 (ou autre touche dépendant de votre configuration), ou sur le symbole "Play" vert sous le menu Outils).  Toutefois, le fait de démarrer le programme provoquera d'abord une compilation de toute façon donc la plupart du temps on ne demandera qu'une exécution.

Si on essaie maintenant, on découvrira une liste d'erreurs assez imposante compte tenu de la petite taille de notre programme... 

Toutefois ces problèmes seront vite réglés puisqu'il s'agit en fait d'une répétition de la même erreur:  nous avons omis de déclarer nos variables avant de les utiliser.  Il faut en effet les déclarer pour les créer et du coup leur donner un type.  pi, rayon et volume seront nécessairement des nombres .  Notre code devient:

 

  

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {
            float pi; 
			float rayon; 
			float volume;
            string le_rayon_en_caracteres;
            pi = 3.14f;
            le_rayon_en_caracteres = Console.ReadLine();
            rayon = float.Parse(le_rayon_en_caracteres);
            volume = (4  * pi * rayon * rayon * rayon)/3;
            Console.WriteLine(volume);
         }
    }
} 

Vous remarquerez peut-être qu'à mesure qu'on tape ces nouvelles lignes, les erreurs disparaissent dans la liste.  À la fin, plus aucune erreur ne reste.  Toutefois, quelques précisions:

• const float pi = 3.14f;

  Du coup, on peut se débarrasser de la ligne qui assigne la valeur de départ à pi...

   

• Il est possible de déclarer plusieurs variables sur une même ligne si elles sont du même type.  On peut donc fusionner nos déclarations de Rayon et de Volume ainsi:

   

  float rayon, volume;

Notre programme a maintenant l'air de ceci:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {
            const float pi = 3.14f; 
            float rayon, volume;
            string le_rayon_en_caracteres;
            le_rayon_en_caracteres = Console.ReadLine();
            rayon = float.Parse(le_rayon_en_caracteres);
            volume = (4  * pi * rayon * rayon * rayon)/3;
            Console.WriteLine(volume);
         }
    }
}  
      

Essayons la génération:  victoire!  Aucune erreur!  Essayons d'exécuter alors...  On se retrouve devant ceci:

Pas particulièrement invitant...  Est-ce que notre programme est "gelé"?  Eh bien non, il est simplement en train d'exécuter le ReadLine et attend que l'on entre une valeur!  Si on entre quelque chose, on voit le volume s'afficher rapidement et la fenêtre se ferme... C'est là qu'on voit l'importance de l'interface dans un programme!  Notre programme fait le travail voulu mais n'est pas nécessairement très plaisant à utiliser.  Pour l'instant toutefois, on peut s'en tenir à ça. 

Si on voulait et qu'on se sentait assez à l'aise avec tout ces concepts, on pourrait aisément ajouter un Console.Write avant le Console.ReadLine, question de demander à l'usager d'entrer quelque chose au lieu d'attendre bêtement... Un Console.Write fonctionne exactement comme un Console.WriteLine sauf qu'il ne fait pas de retour de chariot à la fin de la ligne - le prochain Write ou WriteLine sera donc écrit sur la même ligne. On pourrait donc ajouter ceci avant notre premier ReadLine:

Console.Write("Entrez le rayon: ")

Remarquez que lorsque l'on veut demander à notre programme d'afficher du texte "tel quel", on placera la chaîne de texte entre guillemets. Si on ne le fait pas, il croira que Entrez est une variable et nous donnera des erreurs. N'oublions pas d'inclure un espace à la fin de la chaîne pour plus de clarté.

On peut faire la même chose juste avant d'afficher le volume, question d'être clair sur ce qu'on affiche:

Console.Write("Le volume de la sphère est ")

Pour éviter que notre fenêtre ne nous soit fermée au nez juste à la fin de l'exécution, on peut exécuter le programme avec Ctrl-F5, c'est à dire "Exécuter sans débogage".  On verra plus tard toutefois que le débogage est bien utile en cours de tests - et n'oublions pas que nos usagers de chez Bouboule-O-Rama n'auront pas accès à cette option.  À ce moment-là, on peut simplement ajouter un Console.ReadLine() tout seul comme dernière ligne afin de simuler une pause.  Le ReadLine attendra que l'usager entre une ligne mais ne fera rien avec cette ligne et le programme se terminera ensuite.  Ceci aura donc pour effet de faire une pause en attendant qu'on appuie sur Enter pour terminer. Question d'être clair (encore une fois), on peut faire un Console.WriteLine pour indiquer à l'usager que l'on attend qu'il appuie sur Enter pour terminer:

Console.WriteLine("Appuyez sur ENTER pour terminer")

Console.ReadLine()

Si on a opté pour l'amélioration de la qualité de l'interface, notre code ressemble donc maintenant à ceci:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {
            const float pi = 3.14f; 
            float rayon, volume;
            string le_rayon_en_caracteres;
            Console.Write("Entrez le rayon: ");
            le_rayon_en_caracteres = Console.ReadLine();
            rayon = float.Parse(le_rayon_en_caracteres);
            volume = (4  * pi * rayon * rayon * rayon)/3;
            Console.Write("Le volume de la sphère est ");
            Console.WriteLine(volume);
            Console.WriteLine("Appuyez sur ENTER pour terminer");
            Console.ReadLine();
         }
    }
}

      

Notez que si vous aviez remis comme travail le code précédent, sans ces améliorations, vous vous seriez quand même mérité une note de 100% pour l'instant, puisque nous sommes encore fort débutants. Toutefois, lorsque vous aurez acquis un peu d'expérience, je serai plus exigeant sur ce genre de détails.

Retour à la table des matières de la section

2.3 – Les commentaires

Un commentaire est une ligne (ou une fin de ligne) qui sera ignorée par le compilateur et qui n'est utile que pour les humains qui liront le code.  C'est une excellente pratique que de commenter son code – il est en effet beaucoup plus facile de modifier du code créé par quelqu'un d'autre s'il est bien commenté.  Même si on modifie nous-mêmes notre propre code, après un certain temps on risque d'avoir oublié ce qu'on avait fait la dernière fois et les commentaires nous seront bien utiles. Dans ce cours, vous devrez au minimum faire une entête en commentaires au début de votre programme pour y indiquer:

De plus, vous pourrez mettre des commentaires ailleurs dans le code pour le rendre plus clair – ceci est laissé à votre jugement.  Il est inutile de commenter chaque ligne pour expliquer ce qu'elle fait mais lorsque vos projets deviendront plus gros, c'est une bonne idée de commenter les sections importantes et les parties moins claires. Un commentaire commence simplement par une apostrophe et se termine à la fin de la ligne.  Tout ce qui est entre les deux slash sera ignoré par le compilateur.  Notre programme pourrait alors devenir:

  
//Calculateur de volume de  sphères       
//Programme écrit par Georges  DuRégis       
//Le 31 février 2020 :-)
//Il accepte un rayon et affiche le volume de la sphère correspondante       

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Bouboule
{
    class Program
    {
        static void Main(string[] args)
        {
            const float pi = 3.14f; //Estimation de la valeur de pi
            float rayon, volume;
            string le_rayon_en_caracteres;
            Console.Write("Entrez le rayon: ");
            le_rayon_en_caracteres = Console.ReadLine();
            rayon = float.Parse(le_rayon_en_caracteres);
            volume = (4  * pi * rayon * rayon * rayon)/3;//Calcul du  volume d'une sphère
            Console.Write("Le volume de la sphère est ");
            Console.WriteLine(volume);
            Console.WriteLine("Appuyez sur ENTER pour terminer");
            Console.ReadLine();
         }
    }
}

Retour à la table des matières de la section

2.4 – Sauvegarder notre projet

N'oubliez pas de sauvegarder régulièrement votre projet!  Il arrive de temps en temps qu'un problème survienne et mieux vaut perdre quelques minutes de travail depuis notre dernière sauvegarde que de tout perdre au grand complet – des heures de dur labeur. On peut cliquer sur Enregistrer ou "Enregistrer tout" (utile quand on travaille avec plusieurs fichiers) ou simplement faire CTRL-S.  Si vous allez voir après coup dans le répertoire où vous avez placé votre projet, vous y trouverez plusieurs fichiers:

Qu'est-ce qui est important là-dedans?  À la base, tout, mais si on vous faite une copie de notre projet on n'est pas obligés de tout copier. Premièrement, les répertoires bin et obj ne contiennent que le résultat de votre compilation.  Ce n'est donc pas nécessaire de les conserver puisqu'on peut les générer aisément à partir du code.  Comme c'est normalement ces répertoires qui prennent le plus d'espace, c'est une bonne chose de les effacer lorsque notre projet est d'envergure.

À l'inverse, si vous voulez donner votre exécutable à quelqu'un, c'est dans bin/Debug que vous le trouverez. 

Le fichier le plus important de votre projet est sans contredit Program.cs car c'est dans ce fichier que vous avez créé votre code.  Les autres fichiers sont plutôt des ressources, informations sur des assemblées et configuration de votre projet et peuvent être recréés simplement en créant un autre projet.

Le fichier .sln est le fichier solution – si vous ouvrez ce fichier, Visual Studio pourra retrouver tous les fichiers pertinents à votre projet.  C'est une bonne façon d'ouvrir votre projet pour y travailler.

En conclusion, si vous ne devez que sauvegarder un seul fichier de votre projet, ce sera le fichier Program.cs. Mais si vous voulez conserver votre projet sur une clé USB pour l'apporter chez vous, il est plus simple de copier le répertoire du projet au grand complet (en effaçant les répertoires bin et obj si on manque d'espace et que le projet est gros).

Retour à la table des matières de la section

 

Etienne Forest, modifié par rachid kadouche 17 octobre, 2017